// Copyright (c) 2005  INRIA Sophia-Antipolis (France).
// All rights reserved.
//
// This file is part of cgal-python; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; version 2.1 of the License.
// See the file LICENSE.LGPL distributed with cgal-python.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $Id: Py_Triangulation_3_doc.h 159 2007-11-02 09:54:13Z spion $
// $URL: svn+ssh://scm.gforge.inria.fr/svn/cgal-python/trunk/cgal-python/bindings/Triangulations_3/Py_Triangulation_3_doc.h $
//
// Author(s)     : Naceur Meskini
//=========================================================================

#ifndef TRIANGULATION_2_DOCS_H
#define TRIANGULATION_2_DOCS_H
//=======================================================
// doc of Triangulation_3 class
//=======================================================
const char* Triangulation_3_doc = " \
	The class Triangulation_3 represents a 3-dimensional tetrahedralization of points.\n\
	For more details see:\n\
	http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Triangulation_3_ref/Class_Triangulation_3.html";

const char* swap_doc="\
	t.swap ( self, Triangulation_3 tr ) \n\
	The triangulations tr and t are swapped.\n\
	t.swap(tr ) should be preferred to t = tr or to t(tr) if tr is deleted after that.\n \
	Indeed, there is no copy of cells and vertices, thus this method runs in constant time.";

const char* clear_doc="\
	t.clear( self ) -> Deletes all finite vertices and all cells of t.\n";

const char* dimension_doc="\
	t.dimension( self )  -> int\n\
	Returns the dimension of the affine hull.\n";

const char* number_of_vertices_doc="\
	t.number_of_vertices( self ) -> int \n\
	Returns the number of finite vertices.";

const char* number_of_facets_doc="\
	t.number_of_facets( self ) -> int\n\
	The number of facets. Returns 0 if t.dimension()<2.";

const char* infinite_vertex_doc="\
	t.infinite_vertex( self ) -> Vertex\n\
	Returns the infinite vertex.";

const char* finite_vertex_doc="\
	t.finite_vertex( self ) -> Vertex\n\
	Returns the finite vertex.";

const char* infinite_cell_doc="\
	t.infinite_cell( self ) -> Cell\n\
	Returns a cell incident to the infinite vertex.";

const char* is_infinite_doc="\
	t.is_infinite( self ,Vertex v ) -> bool\n\
	true, iff vertex v is the infinite vertex.\n\n\
	t.is_infinite( self,const Cell c) -> bool\n\
	true, iff c is incident to the infinite vertex.\n\
	Precondition: t.dimension() =3.\n\n\
	t.is_infinite( self, Cell c, int i) -> bool\n\
	true, iff the facet i of cell c is incident to the infinite vertex.\n\
	Precondition: t.dimension() >= 2 and i belongs to {0,1,2,3} in dimension 3, i=3 in dimension 2.\n\n\
	t.is_infinite( self , Facet f) -> bool\n\
	true iff facet f is incident to the infinite vertex.\n\
	Precondition: t.dimension() 2.\n\n\
	t.is_infinite( self , Cell c, int i, int j) -> bool\n\
	true, iff the edge (i,j) of cell c is incident to the infinite vertex.\n\
	Precondition: t.dimension() 1 and i # j. Moreover i,j belongs to {0,1,2,3} in dimension 3,\n\
	i,j belongs to {0,1,2} in dimension 2, i,j belongs to {0,1} in dimension 1.\n\n\
	t.is_infinite( self , Edge e) -> bool \n\
	true iff edge e is incident to the infinite vertex.\n\
	Precondition: t.dimension() >= 1.";

const char* is_edge_doc="\
	t.is_edge( self , Vertex u,Vertex v,Cell c,Edge e) -> bool\n\
	Tests whether (u,v) is an edge of t and computes this edge e.\n\
	Precondition: u and v are vertices of t.";

const char* is_facet_doc="\
	t.is_facet( self , Vertex u,Vertex v,Vertex w,Cell c,list l) -> bool\n\
	Tests whether (u,v,w) is a facet of t. If the facet is found, \n\
	it gives a cell c having this facet and the list l of indices of \n\
	the vertices u ,v and w in c, in this order.\n\
	Precondition: u ,v and w are vertices of t.";

const char* is_cell_doc="\
	t.is_cell( self , Cell c) -> bool\n\
	Tests whether c is a cell of t.\n\n\
	is_cell( self , Vertex u,Vertex v,Vertex w,Vertex x,Cell c) -> bool\n\
	Tests whether (u,v,w,x) is a cell of t and computes this cell c.\n\
	Precondition: u, v, w and x are vertices of t.";

const char* locate_doc="\
  	t.locate( self, Point_3 query,Cell start = Cell()) ->Cell\n\
	If the point query lies inside the convex hull of the points, \n\
	the cell that contains the query in its interior is returned. \n\
	If query lies on a facet, an edge or on a vertex, one of the \n\
	cells having query on its boundary is returned.\n\
	If the point query lies outside the convex hull of the points, \n\
	an infinite cell with vertices { p, q, r, } is returned such that\n\
	the tetrahedron ( p, q, r, query ) is positively oriented \n\
	(the rest of the triangulation lies on the other side of facet ( p, q, r )).\n\
	Note that locate works even in degenerate dimensions: in dimension 2 \n\
	(resp. 1, 0) the Cell returned is the one that represents the facet \n\
	(resp. edge, vertex) containing the query point.\n\
	The optional argument start is used as a starting place for the search.\n\n\
  	t.locate( self, Point_3 query,list [lt,li,lj]) ->Cell\n\
	If query lies inside the affine hull of the points,\n\
	the k-face (finite or infinite) that contains query in its interior is returned,\n\
	by means of the cell returned together with lt, \n\
	which is set to the locate type of the query \n\
	(VERTEX, EDGE, FACET, CELL, or OUTSIDE_CONVEX_HULL if the cell is \n\
	infinite and query lies strictly in it) and two indices li and lj that \n\
	specify the k-face of the cell containing query.\n\
	If the k-face is a cell, li and lj have no meaning; \n\
	if it is a facet (resp. vertex), li gives the index of the facet \n\
	(resp. vertex) and lj has no meaning; if it is and edge, \n\
	li and lj give the indices of its vertices.\n\
	If the point query lies outside the affine hull of the points,\n\
	which can happen in case of degenerate dimensions, \n\
	lt is set to OUTSIDE_AFFINE_HULL, and the cell returned has no meaning.\n\
	As a particular case, if there is no finite vertex yet in the triangulation,\n\
	lt is set to OUTSIDE_AFFINE_HULL and locate returns the default constructed handle.";

const char* side_of_cell_doc="\
	t.side_of_cell( self ,Point p,Cell c,List [lt,li,lj]) -> Bounded_side\n\
	Returns a value indicating on which side of the oriented boundary of c the point p lies.\n\
	More precisely, it returns:\n\
	- ON_BOUNDED_SIDE if p is inside the cell. For an infinite cell\n\
	this means that p lies strictly in the half space limited \n\
	by its finite facet and not containing any other point of the triangulation.\n\
	- ON_BOUNDARY if p on the boundary of the cell. \n\
	For an infinite cell this means that p lies on the finite facet. \n\
	Then lt together with li and lj give the precise location on the boundary.\n\
	(See the descriptions of the locate methods.)\n\
	- ON_UNBOUNDED_SIDE if p lies outside the cell. \n\
	For an infinite cell this means that p does not satisfy either of the two previous conditions.\n\
	Precondition: t.dimension() =3";

const char* side_of_facet_doc="\
	t.side_of_facet( self ,Point p,Facet c,List [lt,li,lj]) -> Bounded_side\n\
	Returns a value indicating on which side of the oriented boundary of f the point p lies.\n\
	More precisely, it returns:\n\
	- ON_BOUNDED_SIDE if p is inside the facet. For an infinite facet\n\
	this means that p lies strictly in the half space limited \n\
	by its finite facet and not containing any other point of the triangulation.\n\
	- ON_BOUNDARY if p on the boundary of the facet. \n\
	For an infinite facet this means that p lies on the finite facet. \n\
	Then lt together with li and lj give the precise location on the boundary.\n\
	(See the descriptions of the locate methods.)\n\
	- ON_UNBOUNDED_SIDE if p lies outside the facet. \n\
	For an infinite facet this means that p does not satisfy either of the two previous conditions.\n\
	Precondition: t.dimension() =2 and p lies in the plane containing the\n\
	triangulation. f.second =3 (in dimension 2 there is only one facet per cell).\n\n\
	t.side_of_facet( self ,Point p,Cell c,List [lt,li,lj]) -> Bounded_side\n\
	Same as the previous method for the facet (c,3).";

const char* side_of_edge_doc="\
	t.side_of_edge( self ,Point p,Edge e,List [lt,li]) -> Bounded_side\n\
	Returns a value indicating on which side of the oriented boundary of f the point p lies.\n\
	More precisely, it returns:\n\
	- ON_BOUNDED_SIDE if p is inside the edge.\n\
	For an infinite edge this means that p lies in the half line defined\n\
	by the vertex and not containing any other point of the triangulation.\n\
	- ON_BOUNDARY if p equals one of the vertices,li give the index of\n\
	the vertex in the cell storing e\n\
	(See the descriptions of the locate methods.)\n\
	- ON_UNBOUNDED_SIDE if p lies outside the edge. For an infinite edge this means that p lies on the other half line, which contains the other points of the triangulation.\n\
	Precondition: t.dimension() =1 and p is collinear with the points of the\n\
	triangulation. e.second =0 and e.third =1 (in dimension 1 there is only one edge per cell)\n\n\
	t.side_of_edge( self ,Point p,Cell c,List [lt,li]) -> Bounded_side\n\
 	Same as the previous method for edge(c,0,1).";

const char* flip_doc="\
	t.flip( self,Edge e) -> bool\n\n\
	t.flip( self,Cell c, int i, int j) -> bool\n\
	Before flipping, these methods check that edge e=(c,i,j) is flippable\n\
 	(which is quite expensive). They return false or true according to this test.\n\n\
	t.flip( self,Facet f) -> bool\n\n\
	t.flip( self,Cell c, int i) -> bool\n\
 	Before flipping, these methods check that facet f=(c,i) is flippable \n\
	(which is quite expensive). They return false or true according to this test.";

const char* insert_doc="\
	t.insert( self,Point_3 p, Cell start = Cell()) -> Vertex\n\
	Inserts point p in the triangulation and returns the corresponding vertex.\n\
	If point p coincides with an already existing vertex, this vertex is returned \n\
	and the triangulation remains unchanged.\n\
	If point p lies in the convex hull of the points, it is added naturally: \n\
	if it lies inside a cell, the cell is split into four cells, if it lies on a facet, \n\
	the two incident cells are split into three cells, if it lies on an edge, all \n\
	the cells incident to this edge are split into two cells.\n\
	If point p is strictly outside the convex hull but in the affine hull, p is linked\n\
	to all visible points on the convex hull to form the new triangulation.\n\
	If point p is outside the affine hull of the points, p is linked to all the points, \n\
	and the dimension of the triangulation is incremented.\n\
	All the points now belongs to the boundary of the convex hull, so, the infinite vertex \n\
	is linked to all the points to triangulate the new infinite face.\n\
	The optional argument start is used as a starting place for the search.\n\n\
	t.insert( self,Point p,Locate_type lt,Cell loc,int li,int lj) -> Vertex\n\
	Inserts point p in the triangulation and returns the corresponding vertex. \n\
	Similar to the above insert() function, but takes as additional parameter \n\
	the return values of a previous location query.\n\n\
	t.insert( self,list l) -> Vertex\n\
 	Inserts a list l of points in the triangulation and returns the number of inserted points.";

const char* insert_in_cell_doc="\
	t.insert_in_cell( self ,Point_3 p, Cell c) -> Vertex\n\
	Inserts point p in cell c. Cell c is split into 4 tetrahedra.\n\
	Precondition: t.dimension() =3 and p lies strictly inside cell c.";

const char* insert_in_facet_doc="\
	t.insert_in_facet( self ,Point_3 p, Facet f) -> Vertex\n\
	Inserts point p in facet f. In dimension 3, \n\
	the 2 neighboring cells are split into 3 tetrahedra; \n\
	in dimension 2, the facet is split into 3 triangles.\n\
	Precondition: t.dimension() 2 and p lies strictly inside face f.\n\n\
	t.insert_in_facet( self ,Point_3 p, Cell c, int i) -> Vertex\n\
	As above, insertion in facet (c,i).\n\
	Precondition: As above and i belongs to {0,1,2,3} in dimension 3, i = 3 in dimension 2.";

const char* insert_in_edge_doc="\
	t.insert_in_edge( self ,Point_3 p, Edge e) -> Vertex\n\
 	Inserts p in edge e. In dimension 3, \n\
	all the cells having this edge are split into 2 tetrahedra; \n\
	in dimension 2, the 2 neighboring facets are split into 2 triangles; \n\
	in dimension 1, the edge is split into 2 edges.\n\
	Precondition: t.dimension() 1 and p lies on edge e.\n\n\
	t.insert_in_edge( self ,Point_3 p, Cell c, int i,int j) -> Vertex\n\
 	As above, inserts p in edge (i, j) of c.\n\
	Precondition: As above and i # j. Moreover i,j belongs to {0,1,2,3} in dimension 3,\n\
	i,j belongs to {0,1,2} in dimension 2, i,j belongs to {0,1} in dimension 1. ";


const char* insert_outside_convex_hull_doc="\
	t.insert_outside_convex_hull( self,Point_3 p, Cell c) -> Vertex\n\
	The cell c must be an infinite cell containing p.\n\
	Links p to all points in the triangulation that are visible from p.\n\
	Updates consequently the infinite faces. See Figure 22.9.\n\
	Precondition: t.dimension() >0, c, and the k-face represented by c \n\
	is infinite and contains t.";

const char* insert_outside_affine_hull_doc="\
t.insert_outside_affine_hull( self ,Point_3 p) -> Vertex\n\
	p is linked to all the points, and the infinite vertex is linked \n\
	to all the points (including p) to triangulate the new infinite face, \n\
	so that all the points now belong to the boundary of the convex hull.\n\
	This method can be used to insert the first point in an empty triangulation.\n\
	Precondition: t.dimension() <3 and p lies outside the affine hull of the points.";
const char* triangle_doc="\
	t.triangle( self , Cell c, int i) -> Triangle_3\n\
	Returns the triangle formed by the three vertices of facet (c,i). \n\
	The triangle is oriented so that its normal points to the inside of cell c.\n\
	Precondition: t.dimension() 2 and i belongs to {0,1,2,3} in dimension 3, \n\
	i = 3 in dimension 2, and the facet is finite.\n\n\
	t.triangle( self , Facet f ) -> Triangle_3\n\
 	Same as the previous method for facet f.\n\
	Precondition: t.dimension() >= 2 and the facet is finite.";

const char* segment_doc="\
	t.segment( self, Edge e) -> Segment_3\n\
	Returns the line segment formed by the vertices of e.\n\
	Precondition: t.dimension() 1 and e is finite.\n\n\
	t.segment( self, Cell c, int i, int j) -> Segment_3\n\
	Same as the previous method for edge (c,i,j).\n\
	Precondition: As above and i j. Moreover i,j belongs to {0,1,2,3} in dimension 3,\n\
	i,j belongs to {0,1,2} in dimension 2, i,j belongs to {0,1} in dimension 1.";

///////////////
char const* vertices_doc="\
	t.vertices -> is an iterator to finites vertices of the triangulation_3 t\n\
	we can use this in for statment like that:\n\
	for v in t.vertices:\n\
		print v.point().x(),v.point().y(),v.point().z()";
const char* all_vertices_doc="\
	t.vertices -> is an iterator to finites vertices of the triangulation_3 t\n\
	we can use this in for statment like that:\n\
	for v in t.all_vertices:\n\
		print v.point().x(),v.point().y(),v.point().z()";
const char* edges_doc="\
	t.edges -> is an iterator to finites edges of the triangulation_3 t\n\
	we can use this in for statment like that:\n\
	for e in t.edges:\n\
		e.some_function()";
const char* all_edges_doc="\
	t.vertices -> is an iterator to finites vertices of the triangulation_3 t\n\
	we can use this in for statment like that:\n\
	for v in t.vertices:\n\
		print v.point().x(),v.point().y(),v.point().z()";
const char* facets_doc="\
	t.vertices -> is an iterator to finites vertices of the triangulation_3 t\n\
	we can use this in for statment like that:\n\
	for v in t.vertices:\n\
		print v.point().x(),v.point().y(),v.point().z()";
const char* all_facets_doc="\
	t.vertices -> is an iterator to finites vertices of the triangulation_3 t\n\
	we can use this in for statment like that:\n\
	for v in t.vertices:\n\
		print v.point().x(),v.point().y(),v.point().z()";

const char* cells_doc="\
	t.vertices -> is an iterator to finites vertices of the triangulation_3 t\n\
	we can use this in for statment like that:\n\
	for v in t.vertices:\n\
		print v.point().x(),v.point().y(),v.point().z()";
const char* all_cells_doc="\
	t.vertices -> is an iterator to finites vertices of the triangulation_3 t\n\
	we can use this in for statment like that:\n\
	for v in t.vertices:\n\
		print v.point().x(),v.point().y(),v.point().z()";
///////////////////
const char* incident_facets_doc="\
	t.incident_facets( self , Edge e) -> Facet_circulator\n\
	Starts at an arbitrary facet incident to e.\n\
	Precondition: t.dimension() =3\n\n\
	t.incident_facets( self , Cell c,int i,int j) -> Facet_circulator\n\
 	As above for edge (i,j) of c.\n\n\
	t.incident_facets( self , Edge e,Facet start) -> Facet_circulator\n\
	Starts at facet start.\n\
	Precondition: start is incident to e.\n\n\
	t.incident_facets( self , Edge e , Cell start ,int f) -> Facet_circulator\n\
 	Starts at facet of index f in start.\n\n\
	t.incident_facets( self, Cell c,int i,int j,Facet start) -> Facet_circulator\n\
	As above for edge (i,j) of c.\n\n\
	t.incident_facets( self , Cell c,int i,int j,Cell start,int f)-> Facet_circulator\n\
	As above for edge (i,j) of c and facet (start,f).\n\n\
  	t.incident_facets (self,Vertex v) -> list of facets\n\
	Returns a list of all the Facets incident to v.\n\
	Precondition: t.dimension()=3, v # Vertex(), t.is_vertex(v).";

const char* incident_cells_doc="\
	t.incident_cells( self,Edge e) -> Cell_circulator\n\
	Starts at an arbitrary cell incident to e.\n\
	Precondition: t.dimension() =3.\n\n\
	t.incident_cells( self, Cell c, int i, int j) -> Cell_circulator\n\
	As above for edge (i,j) of c.\n\n\
	t.incident_cells( self, Edge e, Cell start) -> Cell_circulator\n\
	Starts at cell start.\n\
	Precondition: t.dimension() =3 and start is incident to e.\n\n\
	t.incident_cells( self, Cell c,int i,int j,Cell start) -> Cell_circulator\n\
	As above for edge (i,j) of c.\n\n\
	t.incident_cells( self, Vertex v) -> list of cells\n\
	Returns a list of all cells incident to v.\n\
	If t.dimension() <3, then do nothing. \n\
	Returns the resulting iterator.\n\
	Precondition: v # Vertex(), t.is_vertex(v).";

const char* incident_vertices_doc="\
  	t.incident_vertices( self , Vertex v) -> list of vertices\n\
	Returns a list of all vertices incident to v. \n\
	If t.dimension() <2, then do nothing. \n\
	Returns the resulting iterator.\n\
	Precondition: v # Vertex(), t.is_vertex(v).";

const char* number_of_cells_doc ="\
	t.number_of_cells( self) -> int\n\
	Returns the number of cells or 0 if t.dimension()<3.";

const char* number_of_edges_doc ="\
	t.number_of_edges( self) -> int\n\
	The number of edges. Returns 0 if t.dimension()<1.";

const char* number_of_finite_cells_doc ="\
	t.number_of_finite_cells( self) -> int\n\
	The number of finite cells. Returns 0 if t.dimension()<3.";

const char* number_of_finite_facets_doc ="\
	t.number_of_finite_facets( self) -> int\n\
	The number of finite facets. Returns 0 if t.dimension()<2.";

const char* number_of_finite_edges_doc ="\
	t.number_of_finite_edges( self) -> int\n\
	The number of finite edges. Returns 0 if t.dimension()<1.";

const char* tetrahedron_doc ="\
	t.tetrahedron( self, Cell c) -> Tetrahedron_3\n\
	Returns the tetrahedron formed by the four vertices of c.\n\
	Precondition: t.dimension() =3 and the cell is finite.";

const char* is_valid_doc ="\
	t.is_valid( self, bool verbose = false) -> bool\n\
	Checks the combinatorial validity of the triangulation. \n\
	Checks also the validity of its geometric embedding (see Section 22.1).\n\
	When verbose is set to true, messages describing the first invalidity \n\
	encountered are printed.\n\n\
	t.is_valid( self, Cell c, bool verbose = false) -> bool\n\
	Checks the combinatorial validity of the cell by calling the is_valid \n\
	method of the TriangulationDataStructure_3 cell class. Also checks the \n\
	geometric validity of c, if c is finite.\n\
	When verbose is set to true, messages are printed to give a precise \n\
	indication of the kind of invalidity encountered.";

const char* has_vertex_doc ="\
	t.has_vertex ( self , Facet f, Vertex v) -> bool\n\n\
	t.has_vertex ( self , Cell c, int i, Vertex v) -> bool";

const char* is_vertex_doc ="\
	t.is_vertex( self ,Point p, Vertex  v) -> bool\n\
	Tests whether p is a vertex of t by locating p in the triangulation.\n\
	If p is found, the associated vertex v is given.\n\n\
	t.is_vertex( self ,Vertex v) -> bool\n\
	Tests whether v is a vertex of t.";

const char* are_equal_doc ="\
	t.are_equal( self ,Cell c,int i,Cell n,int j) -> bool\n\n\
	t.are_equal( self ,Facet f, Facet g) -> bool\n\n\
	t.are_equal( self ,Facet f, Cell n, int j) -> bool\n\
	For these three methods:\n\
	Precondition: t.dimension()=3.";

const char* degree_doc ="\
	t.degree( self ,Vertex v) -> int\n\
	Returns the degree of a vertex, that is, the number of incident vertices. \n\
	The infinite vertex is counted.\n\
	Precondition: v Vertex(), t.is_vertex(v).";

const char* insert_in_hole_doc ="\
	t.insert_in_hole(self,Point_3 p ,list_of_cells l,Cell c,int i) -> Vertex\n\
 	Creates a new vertex by starring a hole. \n\
	It takes a list of cells l which specifies a hole: a set of connected cells\n\
	(resp. facets in dimension 2) which is star-shaped wrt p.";
#endif  //TRIANGULATION_2_DOCS_H
//====================

